package com.wzy.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.wzy.base.exception.CustomException;
import com.wzy.base.model.PageParams;
import com.wzy.base.model.PageResult;
import com.wzy.base.model.RestResponse;
import com.wzy.media.feignclient.ContentFeignClient;
import com.wzy.media.feignclient.TeachplanMedia;
import com.wzy.media.mapper.MediaFilesMapper;
import com.wzy.media.mapper.MediaProcessMapper;
import com.wzy.media.model.dto.QueryMediaParamsDto;
import com.wzy.media.model.dto.UploadFileParamsDto;
import com.wzy.media.model.dto.UploadFileResultDto;
import com.wzy.media.model.po.MediaFiles;
import com.wzy.media.model.po.MediaProcess;
import com.wzy.media.service.MediaFileService;
import io.minio.*;
import io.minio.errors.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author wzy
 * @Date 2024/1/11 20:17
 * @description: 媒资文件管理业务实现类
 */
@Service
@Slf4j
public class MediaFileServiceImpl implements MediaFileService {

    @Autowired
    private MediaFilesMapper mediaFilesMapper;
    @Autowired
    private MinioClient minioClient;
    @Autowired
    private MediaFileService mediaFileService;
    @Autowired
    private MediaProcessMapper mediaProcessMapper;
    @Autowired
    private ContentFeignClient contentFeignClient;

    //普通文件桶
    @Value("${minio.bucket.files}")
    private String bucket_files;

    //视频桶
    @Value("${minio.bucket.videofiles}")
    private String bucket_video;

    /**
     * 查询媒资信息
     * @param companyId 机构id
     * @param pageParams 分页参数
     * @param queryMediaParamsDto 查询条件
     * @return
     */
    @Override
    public PageResult<MediaFiles> queryMediaFiels(Long companyId , PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {
        //分装查询参数
        LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MediaFiles::getCompanyId,companyId);
        queryWrapper.like(StringUtils.isNotEmpty(queryMediaParamsDto.getFilename()),MediaFiles::getFilename,queryMediaParamsDto.getFilename());
        queryWrapper.eq(StringUtils.isNotEmpty(queryMediaParamsDto.getFileType()),MediaFiles::getFileType,queryMediaParamsDto.getFileType());
        queryWrapper.eq(StringUtils.isNotEmpty(queryMediaParamsDto.getAuditStatus()),MediaFiles::getAuditStatus,queryMediaParamsDto.getAuditStatus());
        //分页对象
        Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
        Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
        List<MediaFiles> records = pageResult.getRecords();
        return new PageResult<>(records,pageResult.getTotal(),pageParams.getPageNo(),pageParams.getPageSize());
    }

    /**
     * 文件上传
     *
     * @param companyId           机构id
     * @param uploadFileParamsDto 上传的文件信息
     * @param localFilePath       本地路径
     * @param objectName
     * @return
     */
    @Override
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath, String objectName) {
        File file = new File(localFilePath);
        if(!file.exists()){
            throw new CustomException("文件不存在");
        }
        //文件名称
        String filename = uploadFileParamsDto.getFilename();
        //文件扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //根据扩展名获得minioType
        String mimeType = getMimeType(extension);
        //文件的md5值
        String fileMd5 = getFileMd5(file);
        //文件的默认目录
        String defaultFolderPath = getDefaultFolderPath();
        //存储到minio中的对象名（带目录）
        if(StringUtils.isEmpty(objectName)){
            objectName = defaultFolderPath+fileMd5+extension;
        }
        //1. 将文件上传到minio
        //将文件上传到minio
        boolean b = addMediaFilesToMinIO(localFilePath, mimeType, bucket_files, objectName);
        if(!b){
            throw new CustomException("文件上传到文件系统失败");
        }
        //文件大小
        uploadFileParamsDto.setFileSize(file.length());
        //2.将文件信息保存到数据库 利用mediaFileService代理对象 处理优化事物最小化
        MediaFiles mediaFiles = mediaFileService.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_files, objectName);
        //准备返回数据
        UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
        BeanUtils.copyProperties(mediaFiles, uploadFileResultDto);
        return uploadFileResultDto;
    }

    /**
     * 文件信息插入数据库
     * @param companyId 机构id
     * @param fileMd5 md5值
     * @param uploadFileParamsDto 上传文件信息
     * @param bucket 桶
     * @param objectName 文件对象名称
     * @return
     */
    @Transactional
    public MediaFiles addMediaFilesToDb(Long companyId, String fileMd5, UploadFileParamsDto uploadFileParamsDto, String bucket, String objectName) {
        //从数据库查询文件
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        if (mediaFiles == null) {
            mediaFiles = new MediaFiles();
            //拷贝基本信息
            BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
            mediaFiles.setId(fileMd5);
            mediaFiles.setFileId(fileMd5);
            mediaFiles.setCompanyId(companyId);
            mediaFiles.setUrl("/" + bucket + "/" + objectName);
            mediaFiles.setBucket(bucket);
            mediaFiles.setFilePath(objectName);
            mediaFiles.setCreateDate(LocalDateTime.now());
            mediaFiles.setAuditStatus("002003");
            mediaFiles.setStatus("1");
            //保存文件信息到文件表
            int insert = mediaFilesMapper.insert(mediaFiles);
            if (insert < 0) {
                log.error("保存文件信息到数据库失败,{}",mediaFiles.toString());
                throw new CustomException("保存文件信息失败");
            }
            //添加到待处理任务表
            addwaitingTask(mediaFiles);
            log.debug("保存文件信息到数据库成功,{}",mediaFiles.toString());
        }
        return mediaFiles;
    }

    /**
     * 将上传的视频信息添加到待处理任务表 用于视频的处理
     * @param mediaFiles
     */
    private void addwaitingTask(MediaFiles mediaFiles) {
        //文件名称
        String filename = mediaFiles.getFilename();
        //获得文件扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //文件的mimeType
        String mimeType = getMimeType(extension);
        //如果是avi视屏则添加到视屏待处理表
        if(mimeType.equals("video/x-msvideo")){
            MediaProcess mediaProcess = new MediaProcess();
            BeanUtils.copyProperties(mediaFiles,mediaProcess,"url");
            mediaProcess.setStatus("1");//未处理
            mediaProcess.setFailCount(0);//失败次数默认为0
            mediaProcess.setCreateDate(LocalDateTime.now());
            mediaProcessMapper.insert(mediaProcess);
        }

    }

    /**
     * 用于检查文件是否存在
     * @param fileMd5 文件的Md5值
     * @return
     */
    @Override
    public RestResponse<Boolean> checkFile(String fileMd5) {
        //1.检查数据库 是否存在对应的文件信息
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);

        //如果数据库中存在 则查Minio中有没有对应的文件
        if(mediaFiles!=null) {
            //获得桶
            String bucket = mediaFiles.getBucket();
            //存储目录
            String filePath = mediaFiles.getFilePath();
            //在Minio中查询
            InputStream inputStream = null;
            try {
                inputStream = minioClient.getObject(GetObjectArgs.builder()
                        .bucket(bucket)
                        .object(filePath)
                        .build());
                if(inputStream!=null){
                    //Minio中也有 说明文件已存在
                    return RestResponse.validfail(false,"文件已存在");
                }
            } catch (Exception e) {
                //throw new CustomException("检查文件出现异常");
            }finally {
                try {
                    if(inputStream!=null){
                        inputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //文件不存在
        return RestResponse.success(true);
    }

    /**
     * 用于检查分块文件是否存在
     * @param fileMd5 分块的MD5值
     * @param chunkIndex 分块序号
     * @return
     */
    @Override
    public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
        //得到分块文件目录
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //分块文件路径
        String chunkFilePath = chunkFileFolderPath+chunkIndex;
        InputStream inputStream = null;
        try {
            inputStream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucket_video)
                    .object(chunkFilePath)
                    .build());
            if(inputStream!=null){
                //Minio中有 说明文件已存在
                return RestResponse.validfail(false,"分块文件已存在");
            }
        } catch (Exception e) {
           // throw new CustomException("检查分块文件出现异常");
        }finally {
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //分块文件不存在
        return RestResponse.success(false);
    }

    /**
     *上传分块文件到Minio
     * @param fileMd5 上传分块的MD5值
     * @param chunk 分块序号
     * @param localChunkFilePath 分块的本地存储路径
     * @return
     */
    @Override
    public RestResponse<Boolean> uploadChunk(String fileMd5, int chunk, String localChunkFilePath) {
        //得到Minio分块目录的路径
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //得到Minio存储分块文件的路径
        String chunkFilePath = chunkFileFolderPath+chunk;
        //mimeType
        String mimeType = getMimeType(null);
        boolean b = addMediaFilesToMinIO(localChunkFilePath, mimeType, bucket_video, chunkFilePath);
        if (!b) {
            log.debug("上传分块文件失败:{}", chunkFilePath);
            return RestResponse.validfail(false, "上传分块失败");
        }
        log.debug("上传分块文件成功:{}",chunkFilePath);
        return RestResponse.success(true);

    }

    /**
     * 合并分块
     * @param companyId  机构id
     * @param fileMd5  文件md5
     * @param chunkTotal 分块总和
     * @param uploadFileParamsDto 文件信息
     * @return
     */
    @Override
    public RestResponse<Boolean> mergeChunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {
        //====合并分块文件到minio======

        //获取分块文件在Minio中的存储路径
        String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
        //获取所有分块文件
        List<ComposeSource> sourceList = Stream.iterate(0, i -> ++i).limit(chunkTotal)
                .map(i -> ComposeSource.builder()
                        .bucket(bucket_video)
                        .object(chunkFileFolderPath.concat(Integer.toString(i))) //concat 连接俩个字符串
                        .build())
                .collect(Collectors.toList());
        //合并分块
        //合并后的文件名称
        String filename = uploadFileParamsDto.getFilename();
        //文件扩展名
        String extName = filename.substring(filename.lastIndexOf("."));
        //合并文件路径
        String mergeFilePath = getFilePathByMd5(fileMd5, extName);
        //合并文件
        try {
            minioClient.composeObject(ComposeObjectArgs.builder()
                    .bucket(bucket_video)
                    .object(mergeFilePath)
                    .sources(sourceList).build());
            log.debug("合并文件成功:{}", mergeFilePath);
        } catch (Exception e) {
            log.debug("合并文件失败,fileMd5:{},异常:{}", fileMd5, e.getMessage(), e);
            return RestResponse.validfail(false, "合并文件失败。");
        }

        //=======验证Md5值 验证文件是否上传完整======

        //下载合并后的文件
        File minioFile = downloadFileFromMinIO(bucket_video, mergeFilePath);
        if (minioFile == null) {
            log.debug("下载合并后的视频失败，mergeFilePath:{}", mergeFilePath);
            return RestResponse.validfail(false, "下载合并后的文件失败");
        }
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(minioFile);
            //minio上文件的MD5值
            String md5Hex = DigestUtils.md5Hex(fileInputStream);
            //比较MD5值 不一致说明文件不完整
            if (!fileMd5.equals(md5Hex)) {
                return RestResponse.validfail(false, "文件合并校验失败，上传失败！");
            }
            //否则文件一致 设置文件大小信息
            uploadFileParamsDto.setFileSize(minioFile.length());
        } catch (IOException e) {
            log.debug("校验文件失败,fileMd5:{},异常:{}", fileMd5, e.getMessage(), e);
            return RestResponse.validfail(false, "文件合并校验失败，最终上传失败。");
        } finally {
            try {
                if(fileInputStream!=null){
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (minioFile != null) {
                minioFile.delete();
            }
        }

        //文件信息入数据库
        mediaFileService.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_video, mergeFilePath);

        //====清除分块文件=====
        clearChunkFile(chunkFileFolderPath, chunkTotal);
        return RestResponse.success(true);
    }

    /**
     * 合并成功后 信息入库后 需要清理minio中的分块文件
     * @param chunkFileFolderPath minio中分块文件的存储路径
     * @param chunkTotal 分块总数
     */
    private void clearChunkFile(String chunkFileFolderPath, int chunkTotal) {
        //获得所有分块文件
        List<DeleteObject> deleteObjectList = Stream.iterate(0, i->++i)
                        .limit(chunkTotal)
                .map(integer -> new DeleteObject(chunkFileFolderPath.concat(String.valueOf(integer))))
                .collect(Collectors.toList());
        RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket_video).objects(deleteObjectList).build();
        Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
        results.forEach(r->{
            DeleteError deleteError = null;
            try {
                deleteError = r.get();
            } catch (Exception e) {
                e.printStackTrace();
                log.error("清除分块文件失败,objectname:{}",deleteError.objectName(),e);
            }
        });
    }

    /**
     * 从Minio下载文件
     * @param bucketVideo 桶
     * @param mergeFilePath 合并后文件路径
     * @return
     */
    public File downloadFileFromMinIO(String bucketVideo, String mergeFilePath) {
        //临时文件
        File tempFile = null;
        FileOutputStream outputStream = null;
        InputStream inputStream =null;
        try {
             inputStream = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketVideo)
                    .object(mergeFilePath)
                    .build());
            //创建临时文件
            tempFile = File.createTempFile("minio",".merge");
            outputStream = new FileOutputStream(tempFile);
            IOUtils.copy(inputStream,outputStream);
            return tempFile;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } else if (inputStream!=null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(tempFile!=null){
                tempFile.deleteOnExit();
            }
        }
        return null;
    }

    /**
     * 得到合并后的文件的地址
     * @param fileMd5 文件id即md5值
     * @param fileExt 文件扩展名
     * @return
     */
    private String getFilePathByMd5(String fileMd5,String fileExt){
        return   fileMd5.substring(0,1) + "/" + fileMd5.substring(1,2) + "/" + fileMd5 + "/" +fileMd5 +fileExt;
    }


    /**
     * 得到分块文件在Minio中的存储位置 存储规则是md5值的前俩位加md5加chunk 这样存储有利于快速查询
     * @param fileMd5
     * @return
     */
    private String getChunkFileFolderPath(String fileMd5) {
        return fileMd5.substring(0,1)+"/"+fileMd5.substring(1,2)+"/"+fileMd5+"/"+"chunk"+"/";
    }
    /**
     * 将文件上传到minio
     * @param localFilePath 文件地址
     * @param mimeType 文件类型(后缀名)
     * @param bucket 桶
     * @param objectName 对象名称
     * @return
     */
    public boolean addMediaFilesToMinIO(String localFilePath, String mimeType, String bucket, String objectName) {

        try {
            UploadObjectArgs uploadObjectArgs = UploadObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .filename(localFilePath)
                    .contentType(mimeType)
                    .build();
            minioClient.uploadObject(uploadObjectArgs);
            log.debug("上传文件到minio成功,bucket:{},objectName:{}",bucket,objectName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            log.error("上传文件到minio出错,bucket:{},objectName:{},错误原因:{}",bucket,objectName,e.getMessage(),e);
            return false;
        }
    }

    @Override
    public MediaFiles getFileById(String mediaId) {
        MediaFiles mediaFiles = mediaFilesMapper.selectById(mediaId);
        return mediaFiles;
    }

    /**
     * 删除媒资文件
     * @param mediaId 媒资id
     */
    @Override
    public void deleteFileByMediaId(String mediaId) {
        //删除之前要判断此媒资文件是否绑定了相关课程
        List<TeachplanMedia> teachPlan = contentFeignClient.getTeachPlanByMediaId(mediaId);
        if(!teachPlan.isEmpty()){
            throw new CustomException("有课程绑定了此文件，不能删除");
        }
        MediaFiles mediaFiles = mediaFilesMapper.selectById(mediaId);//媒资信息
        String bucket = mediaFiles.getBucket();//minio中的桶
        String filePath = mediaFiles.getFilePath();//minio中存储路径
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucket).object(filePath).build());
        } catch (Exception e) {
            throw new CustomException("文件删除失败");
        }
        //如果删除成功 则从数据库中删除该记录
        mediaFilesMapper.deleteById(mediaId);


    }

    //获取文件默认存储目录路径 年/月/日//获取文件默认存储目录路径 年/月/日
    private String getDefaultFolderPath() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String folder = sdf.format(new Date()).replace("-", "/")+"/";
        return folder;

    }

    /**
     * 获取文件 md5值
     * @param file 文件
     * @return
     */
    private String getFileMd5(File file) {
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            String fileMd5 = DigestUtils.md5Hex(fileInputStream);
            return fileMd5;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    /**
     * 根据扩展名获得minioType
     * @param extension 文件扩展名
     * @return
     */
    private String getMimeType(String extension) {
        if(extension==null)
            extension = "";
        //根据扩展名取出mimeType
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
        //通用mimeType，字节流
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
        if(extensionMatch!=null){
            mimeType = extensionMatch.getMimeType();
        }
        return mimeType;
    }
}
